home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / xml / etree / ElementTree.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  25.4 KB  |  910 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'Comment',
  6.     'dump',
  7.     'Element',
  8.     'ElementTree',
  9.     'fromstring',
  10.     'iselement',
  11.     'iterparse',
  12.     'parse',
  13.     'PI',
  14.     'ProcessingInstruction',
  15.     'QName',
  16.     'SubElement',
  17.     'tostring',
  18.     'TreeBuilder',
  19.     'VERSION',
  20.     'XML',
  21.     'XMLParser',
  22.     'XMLTreeBuilder']
  23. import string
  24. import sys
  25. import re
  26.  
  27. class _SimpleElementPath:
  28.     
  29.     def find(self, element, tag):
  30.         for elem in element:
  31.             if elem.tag == tag:
  32.                 return elem
  33.         
  34.  
  35.     
  36.     def findtext(self, element, tag, default = None):
  37.         for elem in element:
  38.             if elem.tag == tag:
  39.                 if not elem.text:
  40.                     pass
  41.                 return ''
  42.         
  43.         return default
  44.  
  45.     
  46.     def findall(self, element, tag):
  47.         if tag[:3] == './/':
  48.             return element.getiterator(tag[3:])
  49.         result = []
  50.         for elem in element:
  51.             if elem.tag == tag:
  52.                 result.append(elem)
  53.                 continue
  54.             tag[:3] == './/'
  55.         
  56.         return result
  57.  
  58.  
  59.  
  60. try:
  61.     import ElementPath
  62. except ImportError:
  63.     ElementPath = _SimpleElementPath()
  64.  
  65. VERSION = '1.2.6'
  66.  
  67. class _ElementInterface:
  68.     tag = None
  69.     attrib = None
  70.     text = None
  71.     tail = None
  72.     
  73.     def __init__(self, tag, attrib):
  74.         self.tag = tag
  75.         self.attrib = attrib
  76.         self._children = []
  77.  
  78.     
  79.     def __repr__(self):
  80.         return '<Element %s at %x>' % (self.tag, id(self))
  81.  
  82.     
  83.     def makeelement(self, tag, attrib):
  84.         return Element(tag, attrib)
  85.  
  86.     
  87.     def __len__(self):
  88.         return len(self._children)
  89.  
  90.     
  91.     def __getitem__(self, index):
  92.         return self._children[index]
  93.  
  94.     
  95.     def __setitem__(self, index, element):
  96.         if not iselement(element):
  97.             raise AssertionError
  98.         self._children[index] = element
  99.  
  100.     
  101.     def __delitem__(self, index):
  102.         del self._children[index]
  103.  
  104.     
  105.     def __getslice__(self, start, stop):
  106.         return self._children[start:stop]
  107.  
  108.     
  109.     def __setslice__(self, start, stop, elements):
  110.         for element in elements:
  111.             if not iselement(element):
  112.                 raise AssertionError
  113.         
  114.         self._children[start:stop] = list(elements)
  115.  
  116.     
  117.     def __delslice__(self, start, stop):
  118.         del self._children[start:stop]
  119.  
  120.     
  121.     def append(self, element):
  122.         if not iselement(element):
  123.             raise AssertionError
  124.         self._children.append(element)
  125.  
  126.     
  127.     def insert(self, index, element):
  128.         if not iselement(element):
  129.             raise AssertionError
  130.         self._children.insert(index, element)
  131.  
  132.     
  133.     def remove(self, element):
  134.         if not iselement(element):
  135.             raise AssertionError
  136.         self._children.remove(element)
  137.  
  138.     
  139.     def getchildren(self):
  140.         return self._children
  141.  
  142.     
  143.     def find(self, path):
  144.         return ElementPath.find(self, path)
  145.  
  146.     
  147.     def findtext(self, path, default = None):
  148.         return ElementPath.findtext(self, path, default)
  149.  
  150.     
  151.     def findall(self, path):
  152.         return ElementPath.findall(self, path)
  153.  
  154.     
  155.     def clear(self):
  156.         self.attrib.clear()
  157.         self._children = []
  158.         self.text = None
  159.         self.tail = None
  160.  
  161.     
  162.     def get(self, key, default = None):
  163.         return self.attrib.get(key, default)
  164.  
  165.     
  166.     def set(self, key, value):
  167.         self.attrib[key] = value
  168.  
  169.     
  170.     def keys(self):
  171.         return self.attrib.keys()
  172.  
  173.     
  174.     def items(self):
  175.         return self.attrib.items()
  176.  
  177.     
  178.     def getiterator(self, tag = None):
  179.         nodes = []
  180.         if tag == '*':
  181.             tag = None
  182.         
  183.         if tag is None or self.tag == tag:
  184.             nodes.append(self)
  185.         
  186.         for node in self._children:
  187.             nodes.extend(node.getiterator(tag))
  188.         
  189.         return nodes
  190.  
  191.  
  192. _Element = _ElementInterface
  193.  
  194. def Element(tag, attrib = { }, **extra):
  195.     attrib = attrib.copy()
  196.     attrib.update(extra)
  197.     return _ElementInterface(tag, attrib)
  198.  
  199.  
  200. def SubElement(parent, tag, attrib = { }, **extra):
  201.     attrib = attrib.copy()
  202.     attrib.update(extra)
  203.     element = parent.makeelement(tag, attrib)
  204.     parent.append(element)
  205.     return element
  206.  
  207.  
  208. def Comment(text = None):
  209.     element = Element(Comment)
  210.     element.text = text
  211.     return element
  212.  
  213.  
  214. def ProcessingInstruction(target, text = None):
  215.     element = Element(ProcessingInstruction)
  216.     element.text = target
  217.     if text:
  218.         element.text = element.text + ' ' + text
  219.     
  220.     return element
  221.  
  222. PI = ProcessingInstruction
  223.  
  224. class QName:
  225.     
  226.     def __init__(self, text_or_uri, tag = None):
  227.         if tag:
  228.             text_or_uri = '{%s}%s' % (text_or_uri, tag)
  229.         
  230.         self.text = text_or_uri
  231.  
  232.     
  233.     def __str__(self):
  234.         return self.text
  235.  
  236.     
  237.     def __hash__(self):
  238.         return hash(self.text)
  239.  
  240.     
  241.     def __cmp__(self, other):
  242.         if isinstance(other, QName):
  243.             return cmp(self.text, other.text)
  244.         return cmp(self.text, other)
  245.  
  246.  
  247.  
  248. class ElementTree:
  249.     
  250.     def __init__(self, element = None, file = None):
  251.         if not element is None and iselement(element):
  252.             raise AssertionError
  253.         self._root = element
  254.         if file:
  255.             self.parse(file)
  256.         
  257.  
  258.     
  259.     def getroot(self):
  260.         return self._root
  261.  
  262.     
  263.     def _setroot(self, element):
  264.         if not iselement(element):
  265.             raise AssertionError
  266.         self._root = element
  267.  
  268.     
  269.     def parse(self, source, parser = None):
  270.         if not hasattr(source, 'read'):
  271.             source = open(source, 'rb')
  272.         
  273.         if not parser:
  274.             parser = XMLTreeBuilder()
  275.         
  276.         while None:
  277.             data = source.read(32768)
  278.             if not data:
  279.                 break
  280.             
  281.             continue
  282.             self._root = parser.close()
  283.             return self._root
  284.  
  285.     
  286.     def getiterator(self, tag = None):
  287.         if not self._root is not None:
  288.             raise AssertionError
  289.         return self._root.getiterator(tag)
  290.  
  291.     
  292.     def find(self, path):
  293.         if not self._root is not None:
  294.             raise AssertionError
  295.         if path[:1] == '/':
  296.             path = '.' + path
  297.         
  298.         return self._root.find(path)
  299.  
  300.     
  301.     def findtext(self, path, default = None):
  302.         if not self._root is not None:
  303.             raise AssertionError
  304.         if path[:1] == '/':
  305.             path = '.' + path
  306.         
  307.         return self._root.findtext(path, default)
  308.  
  309.     
  310.     def findall(self, path):
  311.         if not self._root is not None:
  312.             raise AssertionError
  313.         if path[:1] == '/':
  314.             path = '.' + path
  315.         
  316.         return self._root.findall(path)
  317.  
  318.     
  319.     def write(self, file, encoding = 'us-ascii'):
  320.         if not self._root is not None:
  321.             raise AssertionError
  322.         if not hasattr(file, 'write'):
  323.             file = open(file, 'wb')
  324.         
  325.         if not encoding:
  326.             encoding = 'us-ascii'
  327.         elif encoding != 'utf-8' and encoding != 'us-ascii':
  328.             file.write("<?xml version='1.0' encoding='%s'?>\n" % encoding)
  329.         
  330.         self._write(file, self._root, encoding, { })
  331.  
  332.     
  333.     def _write(self, file, node, encoding, namespaces):
  334.         tag = node.tag
  335.         if tag is Comment:
  336.             file.write('<!-- %s -->' % _escape_cdata(node.text, encoding))
  337.         elif tag is ProcessingInstruction:
  338.             file.write('<?%s?>' % _escape_cdata(node.text, encoding))
  339.         else:
  340.             items = node.items()
  341.             xmlns_items = []
  342.             
  343.             try:
  344.                 if isinstance(tag, QName) or tag[:1] == '{':
  345.                     (tag, xmlns) = fixtag(tag, namespaces)
  346.                     if xmlns:
  347.                         xmlns_items.append(xmlns)
  348.                     
  349.             except TypeError:
  350.                 _raise_serialization_error(tag)
  351.  
  352.             file.write('<' + _encode(tag, encoding))
  353.             if items or xmlns_items:
  354.                 items.sort()
  355.                 for k, v in items:
  356.                     
  357.                     try:
  358.                         if isinstance(k, QName) or k[:1] == '{':
  359.                             (k, xmlns) = fixtag(k, namespaces)
  360.                             if xmlns:
  361.                                 xmlns_items.append(xmlns)
  362.                             
  363.                     except TypeError:
  364.                         _raise_serialization_error(k)
  365.  
  366.                     
  367.                     try:
  368.                         if isinstance(v, QName):
  369.                             (v, xmlns) = fixtag(v, namespaces)
  370.                             if xmlns:
  371.                                 xmlns_items.append(xmlns)
  372.                             
  373.                     except TypeError:
  374.                         _raise_serialization_error(v)
  375.  
  376.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  377.                 
  378.                 for k, v in xmlns_items:
  379.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  380.                 
  381.             
  382.             if node.text or len(node):
  383.                 file.write('>')
  384.                 if node.text:
  385.                     file.write(_escape_cdata(node.text, encoding))
  386.                 
  387.                 for n in node:
  388.                     self._write(file, n, encoding, namespaces)
  389.                 
  390.                 file.write('</' + _encode(tag, encoding) + '>')
  391.             else:
  392.                 file.write(' />')
  393.             for k, v in xmlns_items:
  394.                 del namespaces[v]
  395.             
  396.         if node.tail:
  397.             file.write(_escape_cdata(node.tail, encoding))
  398.         
  399.  
  400.  
  401.  
  402. def iselement(element):
  403.     if not isinstance(element, _ElementInterface):
  404.         pass
  405.     return hasattr(element, 'tag')
  406.  
  407.  
  408. def dump(elem):
  409.     if not isinstance(elem, ElementTree):
  410.         elem = ElementTree(elem)
  411.     
  412.     elem.write(sys.stdout)
  413.     tail = elem.getroot().tail
  414.     if not tail or tail[-1] != '\n':
  415.         sys.stdout.write('\n')
  416.     
  417.  
  418.  
  419. def _encode(s, encoding):
  420.     
  421.     try:
  422.         return s.encode(encoding)
  423.     except AttributeError:
  424.         return s
  425.  
  426.  
  427. if sys.version[:3] == '1.5':
  428.     _escape = re.compile('[&<>\\"\\x80-\\xff]+')
  429. else:
  430.     _escape = re.compile(eval('u"[&<>\\"\\u0080-\\uffff]+"'))
  431. _escape_map = {
  432.     '&': '&',
  433.     '<': '<',
  434.     '>': '>',
  435.     '"': '"' }
  436. _namespace_map = {
  437.     'http://www.w3.org/XML/1998/namespace': 'xml',
  438.     'http://www.w3.org/1999/xhtml': 'html',
  439.     'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf',
  440.     'http://schemas.xmlsoap.org/wsdl/': 'wsdl' }
  441.  
  442. def _raise_serialization_error(text):
  443.     raise TypeError('cannot serialize %r (type %s)' % (text, type(text).__name__))
  444.  
  445.  
  446. def _encode_entity(text, pattern = _escape):
  447.     
  448.     def escape_entities(m, map = _escape_map):
  449.         out = []
  450.         append = out.append
  451.         for char in m.group():
  452.             text = map.get(char)
  453.             if text is None:
  454.                 text = '&#%d;' % ord(char)
  455.             
  456.             append(text)
  457.         
  458.         return string.join(out, '')
  459.  
  460.     
  461.     try:
  462.         return _encode(pattern.sub(escape_entities, text), 'ascii')
  463.     except TypeError:
  464.         _raise_serialization_error(text)
  465.  
  466.  
  467.  
  468. def _escape_cdata(text, encoding = None, replace = string.replace):
  469.     
  470.     try:
  471.         if encoding:
  472.             
  473.             try:
  474.                 text = _encode(text, encoding)
  475.             except UnicodeError:
  476.                 return _encode_entity(text)
  477.             
  478.  
  479.         None<EXCEPTION MATCH>UnicodeError
  480.         text = replace(text, '&', '&')
  481.         text = replace(text, '<', '<')
  482.         text = replace(text, '>', '>')
  483.         return text
  484.     except (TypeError, AttributeError):
  485.         _raise_serialization_error(text)
  486.  
  487.  
  488.  
  489. def _escape_attrib(text, encoding = None, replace = string.replace):
  490.     
  491.     try:
  492.         if encoding:
  493.             
  494.             try:
  495.                 text = _encode(text, encoding)
  496.             except UnicodeError:
  497.                 return _encode_entity(text)
  498.             
  499.  
  500.         None<EXCEPTION MATCH>UnicodeError
  501.         text = replace(text, '&', '&')
  502.         text = replace(text, "'", ''')
  503.         text = replace(text, '"', '"')
  504.         text = replace(text, '<', '<')
  505.         text = replace(text, '>', '>')
  506.         return text
  507.     except (TypeError, AttributeError):
  508.         _raise_serialization_error(text)
  509.  
  510.  
  511.  
  512. def fixtag(tag, namespaces):
  513.     if isinstance(tag, QName):
  514.         tag = tag.text
  515.     
  516.     (namespace_uri, tag) = string.split(tag[1:], '}', 1)
  517.     prefix = namespaces.get(namespace_uri)
  518.     if prefix is None:
  519.         prefix = _namespace_map.get(namespace_uri)
  520.         if prefix is None:
  521.             prefix = 'ns%d' % len(namespaces)
  522.         
  523.         namespaces[namespace_uri] = prefix
  524.         if prefix == 'xml':
  525.             xmlns = None
  526.         else:
  527.             xmlns = ('xmlns:%s' % prefix, namespace_uri)
  528.     else:
  529.         xmlns = None
  530.     return ('%s:%s' % (prefix, tag), xmlns)
  531.  
  532.  
  533. def parse(source, parser = None):
  534.     tree = ElementTree()
  535.     tree.parse(source, parser)
  536.     return tree
  537.  
  538.  
  539. class iterparse:
  540.     
  541.     def __init__(self, source, events = None):
  542.         if not hasattr(source, 'read'):
  543.             source = open(source, 'rb')
  544.         
  545.         self._file = source
  546.         self._events = []
  547.         self._index = 0
  548.         self.root = None
  549.         self._root = None
  550.         self._parser = XMLTreeBuilder()
  551.         parser = self._parser._parser
  552.         append = self._events.append
  553.         if events is None:
  554.             events = [
  555.                 'end']
  556.         
  557.         for event in events:
  558.             if event == 'start':
  559.                 
  560.                 try:
  561.                     parser.ordered_attributes = 1
  562.                     parser.specified_attributes = 1
  563.                     
  564.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start_list):
  565.                         append((event, start(tag, attrib_in)))
  566.  
  567.                     parser.StartElementHandler = handler
  568.                 except AttributeError:
  569.                     
  570.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start):
  571.                         append((event, start(tag, attrib_in)))
  572.  
  573.                     parser.StartElementHandler = handler
  574.                 except:
  575.                     None<EXCEPTION MATCH>AttributeError
  576.                 
  577.  
  578.             None<EXCEPTION MATCH>AttributeError
  579.             if event == 'end':
  580.                 
  581.                 def handler(tag, event = event, append = append, end = self._parser._end):
  582.                     append((event, end(tag)))
  583.  
  584.                 parser.EndElementHandler = handler
  585.                 continue
  586.             if event == 'start-ns':
  587.                 
  588.                 def handler(prefix, uri, event = event, append = append):
  589.                     
  590.                     try:
  591.                         uri = _encode(uri, 'ascii')
  592.                     except UnicodeError:
  593.                         pass
  594.  
  595.                     if not prefix:
  596.                         pass
  597.                     append((event, ('', uri)))
  598.  
  599.                 parser.StartNamespaceDeclHandler = handler
  600.                 continue
  601.             if event == 'end-ns':
  602.                 
  603.                 def handler(prefix, event = event, append = append):
  604.                     append((event, None))
  605.  
  606.                 parser.EndNamespaceDeclHandler = handler
  607.                 continue
  608.         
  609.  
  610.     
  611.     def next(self):
  612.         while None:
  613.             
  614.             try:
  615.                 item = self._events[self._index]
  616.             except IndexError:
  617.                 if self._parser is None:
  618.                     self.root = self._root
  619.                     
  620.                     try:
  621.                         raise StopIteration
  622.                     except NameError:
  623.                         raise IndexError
  624.                     except:
  625.                         None<EXCEPTION MATCH>NameError
  626.                     
  627.  
  628.                 None<EXCEPTION MATCH>NameError
  629.                 del self._events[:]
  630.                 self._index = 0
  631.                 data = self._file.read(16384)
  632.                 if data:
  633.                     self._parser.feed(data)
  634.                 else:
  635.                     self._root = self._parser.close()
  636.                     self._parser = None
  637.                 data
  638.  
  639.             self._index = self._index + 1
  640.             return item
  641.             continue
  642.             return None
  643.  
  644.     
  645.     try:
  646.         iter
  647.         
  648.         def __iter__(self):
  649.             return self
  650.  
  651.     except NameError:
  652.         
  653.         def __getitem__(self, index):
  654.             return self.next()
  655.  
  656.  
  657.  
  658.  
  659. def XML(text):
  660.     parser = XMLTreeBuilder()
  661.     parser.feed(text)
  662.     return parser.close()
  663.  
  664.  
  665. def XMLID(text):
  666.     parser = XMLTreeBuilder()
  667.     parser.feed(text)
  668.     tree = parser.close()
  669.     ids = { }
  670.     for elem in tree.getiterator():
  671.         id = elem.get('id')
  672.         if id:
  673.             ids[id] = elem
  674.             continue
  675.     
  676.     return (tree, ids)
  677.  
  678. fromstring = XML
  679.  
  680. def tostring(element, encoding = None):
  681.     
  682.     class dummy:
  683.         pass
  684.  
  685.     data = []
  686.     file = dummy()
  687.     file.write = data.append
  688.     ElementTree(element).write(file, encoding)
  689.     return string.join(data, '')
  690.  
  691.  
  692. class TreeBuilder:
  693.     
  694.     def __init__(self, element_factory = None):
  695.         self._data = []
  696.         self._elem = []
  697.         self._last = None
  698.         self._tail = None
  699.         if element_factory is None:
  700.             element_factory = _ElementInterface
  701.         
  702.         self._factory = element_factory
  703.  
  704.     
  705.     def close(self):
  706.         if not len(self._elem) == 0:
  707.             raise AssertionError, 'missing end tags'
  708.         if not self._last != None:
  709.             raise AssertionError, 'missing toplevel element'
  710.         return self._last
  711.  
  712.     
  713.     def _flush(self):
  714.         if self._data:
  715.             if self._last is not None:
  716.                 text = string.join(self._data, '')
  717.                 if self._tail:
  718.                     if not self._last.tail is None:
  719.                         raise AssertionError, 'internal error (tail)'
  720.                     self._last.tail = text
  721.                 elif not self._last.text is None:
  722.                     raise AssertionError, 'internal error (text)'
  723.                 self._last.text = text
  724.             
  725.             self._data = []
  726.         
  727.  
  728.     
  729.     def data(self, data):
  730.         self._data.append(data)
  731.  
  732.     
  733.     def start(self, tag, attrs):
  734.         self._flush()
  735.         self._last = elem = self._factory(tag, attrs)
  736.         if self._elem:
  737.             self._elem[-1].append(elem)
  738.         
  739.         self._elem.append(elem)
  740.         self._tail = 0
  741.         return elem
  742.  
  743.     
  744.     def end(self, tag):
  745.         self._flush()
  746.         self._last = self._elem.pop()
  747.         if not self._last.tag == tag:
  748.             raise AssertionError, 'end tag mismatch (expected %s, got %s)' % (self._last.tag, tag)
  749.         self._tail = 1
  750.         return self._last
  751.  
  752.  
  753.  
  754. class XMLTreeBuilder:
  755.     
  756.     def __init__(self, html = 0, target = None):
  757.         
  758.         try:
  759.             expat = expat
  760.             import xml.parsers
  761.         except ImportError:
  762.             raise ImportError('No module named expat; use SimpleXMLTreeBuilder instead')
  763.  
  764.         self._parser = parser = expat.ParserCreate(None, '}')
  765.         if target is None:
  766.             target = TreeBuilder()
  767.         
  768.         self._target = target
  769.         self._names = { }
  770.         parser.DefaultHandlerExpand = self._default
  771.         parser.StartElementHandler = self._start
  772.         parser.EndElementHandler = self._end
  773.         parser.CharacterDataHandler = self._data
  774.         
  775.         try:
  776.             self._parser.buffer_text = 1
  777.         except AttributeError:
  778.             pass
  779.  
  780.         
  781.         try:
  782.             self._parser.ordered_attributes = 1
  783.             self._parser.specified_attributes = 1
  784.             parser.StartElementHandler = self._start_list
  785.         except AttributeError:
  786.             pass
  787.  
  788.         encoding = None
  789.         if not parser.returns_unicode:
  790.             encoding = 'utf-8'
  791.         
  792.         self._doctype = None
  793.         self.entity = { }
  794.  
  795.     
  796.     def _fixtext(self, text):
  797.         
  798.         try:
  799.             return _encode(text, 'ascii')
  800.         except UnicodeError:
  801.             return text
  802.  
  803.  
  804.     
  805.     def _fixname(self, key):
  806.         
  807.         try:
  808.             name = self._names[key]
  809.         except KeyError:
  810.             name = key
  811.             if '}' in name:
  812.                 name = '{' + name
  813.             
  814.             self._names[key] = name = self._fixtext(name)
  815.  
  816.         return name
  817.  
  818.     
  819.     def _start(self, tag, attrib_in):
  820.         fixname = self._fixname
  821.         tag = fixname(tag)
  822.         attrib = { }
  823.         for key, value in attrib_in.items():
  824.             attrib[fixname(key)] = self._fixtext(value)
  825.         
  826.         return self._target.start(tag, attrib)
  827.  
  828.     
  829.     def _start_list(self, tag, attrib_in):
  830.         fixname = self._fixname
  831.         tag = fixname(tag)
  832.         attrib = { }
  833.         if attrib_in:
  834.             for i in range(0, len(attrib_in), 2):
  835.                 attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i + 1])
  836.             
  837.         
  838.         return self._target.start(tag, attrib)
  839.  
  840.     
  841.     def _data(self, text):
  842.         return self._target.data(self._fixtext(text))
  843.  
  844.     
  845.     def _end(self, tag):
  846.         return self._target.end(self._fixname(tag))
  847.  
  848.     
  849.     def _default(self, text):
  850.         prefix = text[:1]
  851.         if prefix == '&':
  852.             
  853.             try:
  854.                 self._target.data(self.entity[text[1:-1]])
  855.             except KeyError:
  856.                 expat = expat
  857.                 import xml.parsers
  858.                 raise expat.error('undefined entity %s: line %d, column %d' % (text, self._parser.ErrorLineNumber, self._parser.ErrorColumnNumber))
  859.             except:
  860.                 None<EXCEPTION MATCH>KeyError
  861.             
  862.  
  863.         None<EXCEPTION MATCH>KeyError
  864.         if prefix == '<' and text[:9] == '<!DOCTYPE':
  865.             self._doctype = []
  866.         elif self._doctype is not None:
  867.             if prefix == '>':
  868.                 self._doctype = None
  869.                 return None
  870.             text = string.strip(text)
  871.             if not text:
  872.                 return None
  873.             self._doctype.append(text)
  874.             n = len(self._doctype)
  875.             if n > 2:
  876.                 type = self._doctype[1]
  877.                 if type == 'PUBLIC' and n == 4:
  878.                     (name, type, pubid, system) = self._doctype
  879.                 elif type == 'SYSTEM' and n == 3:
  880.                     (name, type, system) = self._doctype
  881.                     pubid = None
  882.                 else:
  883.                     return None
  884.                 if prefix == '>':
  885.                     pubid = pubid[1:-1]
  886.                 
  887.                 self.doctype(name, pubid, system[1:-1])
  888.                 self._doctype = None
  889.             
  890.         
  891.  
  892.     
  893.     def doctype(self, name, pubid, system):
  894.         pass
  895.  
  896.     
  897.     def feed(self, data):
  898.         self._parser.Parse(data, 0)
  899.  
  900.     
  901.     def close(self):
  902.         self._parser.Parse('', 1)
  903.         tree = self._target.close()
  904.         del self._target
  905.         del self._parser
  906.         return tree
  907.  
  908.  
  909. XMLParser = XMLTreeBuilder
  910.